/* Error codes: codes for bad device tree blobs */
#define FDT_ERR_TRUNCATED 8
- /* FDT_ERR_TRUNCATED: FDT or a sub-block is improperly
- * terminated (overflows, goes outside allowed bounds, or
- * isn't properly terminated). */
+ /* FDT_ERR_TRUNCATED: Structure block of the given device tree
+ * ends without an FDT_END tag. */
#define FDT_ERR_BADMAGIC 9
/* FDT_ERR_BADMAGIC: Given "device tree" appears not to be a
* device tree at all - it is missing the flattened device
uint32_t fdt_next_tag(const void *fdt, int offset, int *nextoffset);
-/*
- * Alignment helpers:
- * These helpers access words from a device tree blob. They're
- * built to work even with unaligned pointers on platforms (ike
- * ARM) that don't like unaligned loads and stores
- */
-
-static inline uint32_t fdt32_ld(const fdt32_t *p)
-{
- fdt32_t v;
-
- memcpy(&v, p, sizeof(v));
- return fdt32_to_cpu(v);
-}
-
-static inline uint64_t fdt64_ld(const fdt64_t *p)
-{
- fdt64_t v;
-
- memcpy(&v, p, sizeof(v));
- return fdt64_to_cpu(v);
-}
-
/**********************************************************************/
/* Traversal functions */
/**********************************************************************/
/* General functions */
/**********************************************************************/
#define fdt_get_header(fdt, field) \
- (fdt32_ld(&((const struct fdt_header *)(fdt))->field))
+ (fdt32_to_cpu(((const struct fdt_header *)(fdt))->field))
#define fdt_magic(fdt) (fdt_get_header(fdt, magic))
#define fdt_totalsize(fdt) (fdt_get_header(fdt, totalsize))
#define fdt_off_dt_struct(fdt) (fdt_get_header(fdt, off_dt_struct))
#undef fdt_set_hdr_
/**
- * fdt_header_size - return the size of the tree's header
- * @fdt: pointer to a flattened device tree
- */
-size_t fdt_header_size_(uint32_t version);
-static inline size_t fdt_header_size(const void *fdt)
-{
- return fdt_header_size_(fdt_version(fdt));
-}
-
-/**
- * fdt_check_header - sanity check a device tree header
-
+ * fdt_check_header - sanity check a device tree or possible device tree
* @fdt: pointer to data which might be a flattened device tree
*
* fdt_check_header() checks that the given buffer contains what
- * appears to be a flattened device tree, and that the header contains
- * valid information (to the extent that can be determined from the
- * header alone).
+ * appears to be a flattened device tree with sane information in its
+ * header.
*
* returns:
* 0, if the buffer appears to contain a valid device tree
* -FDT_ERR_BADMAGIC,
* -FDT_ERR_BADVERSION,
- * -FDT_ERR_BADSTATE,
- * -FDT_ERR_TRUNCATED, standard meanings, as above
+ * -FDT_ERR_BADSTATE, standard meanings, as above
*/
int fdt_check_header(const void *fdt);
/* Read-only functions */
/**********************************************************************/
-int fdt_check_full(const void *fdt, size_t bufsize);
-
-/**
- * fdt_get_string - retrieve a string from the strings block of a device tree
- * @fdt: pointer to the device tree blob
- * @stroffset: offset of the string within the strings block (native endian)
- * @lenp: optional pointer to return the string's length
- *
- * fdt_get_string() retrieves a pointer to a single string from the
- * strings block of the device tree blob at fdt, and optionally also
- * returns the string's length in *lenp.
- *
- * returns:
- * a pointer to the string, on success
- * NULL, if stroffset is out of bounds, or doesn't point to a valid string
- */
-const char *fdt_get_string(const void *fdt, int stroffset, int *lenp);
-
/**
* fdt_string - retrieve a string from the strings block of a device tree
* @fdt: pointer to the device tree blob
*
* returns:
* a pointer to the string, on success
- * NULL, if stroffset is out of bounds, or doesn't point to a valid string
+ * NULL, if stroffset is out of bounds
*/
const char *fdt_string(const void *fdt, int stroffset);
*
* returns:
* 0 <= n < FDT_MAX_NCELLS, on success
- * 2, if the node has no #size-cells property
+ * 2, if the node has no #address-cells property
* -FDT_ERR_BADNCELLS, if the node has a badly formatted or invalid
* #size-cells property
* -FDT_ERR_BADMAGIC,
fdt64_t tmp = cpu_to_fdt64(val);
return fdt_property(fdt, name, &tmp, sizeof(tmp));
}
-
-#ifndef SWIG /* Not available in Python */
static inline int fdt_property_cell(void *fdt, const char *name, uint32_t val)
{
return fdt_property_u32(fdt, name, val);
}
-#endif
/**
* fdt_property_placeholder - add a new property and return a ptr to its value
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
-#include <limits.h>
#ifdef __CHECKER__
#define FDT_FORCE __attribute__((force))
#include "libfdt_internal.h"
-/*
- * Minimal sanity check for a read-only tree. fdt_ro_probe_() checks
- * that the given buffer contains what appears to be a flattened
- * device tree with sane information in its header.
- */
-int fdt_ro_probe_(const void *fdt)
+int fdt_check_header(const void *fdt)
{
if (fdt_magic(fdt) == FDT_MAGIC) {
/* Complete tree */
return 0;
}
-static int check_off_(uint32_t hdrsize, uint32_t totalsize, uint32_t off)
-{
- return (off >= hdrsize) && (off <= totalsize);
-}
-
-static int check_block_(uint32_t hdrsize, uint32_t totalsize,
- uint32_t base, uint32_t size)
-{
- if (!check_off_(hdrsize, totalsize, base))
- return 0; /* block start out of bounds */
- if ((base + size) < base)
- return 0; /* overflow */
- if (!check_off_(hdrsize, totalsize, base + size))
- return 0; /* block end out of bounds */
- return 1;
-}
-
-size_t fdt_header_size_(uint32_t version)
-{
- if (version <= 1)
- return FDT_V1_SIZE;
- else if (version <= 2)
- return FDT_V2_SIZE;
- else if (version <= 3)
- return FDT_V3_SIZE;
- else if (version <= 16)
- return FDT_V16_SIZE;
- else
- return FDT_V17_SIZE;
-}
-
-int fdt_check_header(const void *fdt)
-{
- size_t hdrsize;
-
- if (fdt_magic(fdt) != FDT_MAGIC)
- return -FDT_ERR_BADMAGIC;
- hdrsize = fdt_header_size(fdt);
- if ((fdt_version(fdt) < FDT_FIRST_SUPPORTED_VERSION)
- || (fdt_last_comp_version(fdt) > FDT_LAST_SUPPORTED_VERSION))
- return -FDT_ERR_BADVERSION;
- if (fdt_version(fdt) < fdt_last_comp_version(fdt))
- return -FDT_ERR_BADVERSION;
-
- if ((fdt_totalsize(fdt) < hdrsize)
- || (fdt_totalsize(fdt) > INT_MAX))
- return -FDT_ERR_TRUNCATED;
-
- /* Bounds check memrsv block */
- if (!check_off_(hdrsize, fdt_totalsize(fdt), fdt_off_mem_rsvmap(fdt)))
- return -FDT_ERR_TRUNCATED;
-
- /* Bounds check structure block */
- if (fdt_version(fdt) < 17) {
- if (!check_off_(hdrsize, fdt_totalsize(fdt),
- fdt_off_dt_struct(fdt)))
- return -FDT_ERR_TRUNCATED;
- } else {
- if (!check_block_(hdrsize, fdt_totalsize(fdt),
- fdt_off_dt_struct(fdt),
- fdt_size_dt_struct(fdt)))
- return -FDT_ERR_TRUNCATED;
- }
-
- /* Bounds check strings block */
- if (!check_block_(hdrsize, fdt_totalsize(fdt),
- fdt_off_dt_strings(fdt), fdt_size_dt_strings(fdt)))
- return -FDT_ERR_TRUNCATED;
-
- return 0;
-}
-
const void *fdt_offset_ptr(const void *fdt, int offset, unsigned int len)
{
unsigned absoffset = offset + fdt_off_dt_struct(fdt);
int fdt_move(const void *fdt, void *buf, int bufsize)
{
- FDT_RO_PROBE(fdt);
+ FDT_CHECK_HEADER(fdt);
if (fdt_totalsize(fdt) > bufsize)
return -FDT_ERR_NOSPACE;
/*
* libfdt - Flat Device Tree manipulation
- * Copyright (C) 2018 embedded brains GmbH
*
* libfdt is dual licensed: you can use it either under the terms of
* the GPL, or the BSD license, at your option.
#include "libfdt_internal.h"
-static int fdt_cells(const void *fdt, int nodeoffset, const char *name)
+int fdt_address_cells(const void *fdt, int nodeoffset)
{
- const fdt32_t *c;
+ const fdt32_t *ac;
int val;
int len;
- c = fdt_getprop(fdt, nodeoffset, name, &len);
- if (!c)
+ ac = fdt_getprop(fdt, nodeoffset, "#address-cells", &len);
+ if (!ac)
return 2;
- if (len != sizeof(*c))
+ if (len != sizeof(*ac))
return -FDT_ERR_BADNCELLS;
- val = fdt32_to_cpu(*c);
+ val = fdt32_to_cpu(*ac);
if ((val <= 0) || (val > FDT_MAX_NCELLS))
return -FDT_ERR_BADNCELLS;
return val;
}
-int fdt_address_cells(const void *fdt, int nodeoffset)
-{
- return fdt_cells(fdt, nodeoffset, "#address-cells");
-}
-
int fdt_size_cells(const void *fdt, int nodeoffset)
{
- return fdt_cells(fdt, nodeoffset, "#size-cells");
+ const fdt32_t *sc;
+ int val;
+ int len;
+
+ sc = fdt_getprop(fdt, nodeoffset, "#size-cells", &len);
+ if (!sc)
+ return 2;
+
+ if (len != sizeof(*sc))
+ return -FDT_ERR_BADNCELLS;
+
+ val = fdt32_to_cpu(*sc);
+ if ((val < 0) || (val > FDT_MAX_NCELLS))
+ return -FDT_ERR_BADNCELLS;
+
+ return val;
}
int len = 0, namelen;
const char *name;
- FDT_RO_PROBE(fdt);
+ FDT_CHECK_HEADER(fdt);
for (;;) {
name = fdt_get_name(fdt, nodeoffset, &namelen);
uint32_t delta = fdt_get_max_phandle(fdt);
int ret;
- FDT_RO_PROBE(fdt);
- FDT_RO_PROBE(fdto);
+ FDT_CHECK_HEADER(fdt);
+ FDT_CHECK_HEADER(fdto);
ret = overlay_adjust_local_phandles(fdto, delta);
if (ret)
return 0;
}
-const char *fdt_get_string(const void *fdt, int stroffset, int *lenp)
-{
- uint32_t absoffset = stroffset + fdt_off_dt_strings(fdt);
- size_t len;
- int err;
- const char *s, *n;
-
- err = fdt_ro_probe_(fdt);
- if (err != 0)
- goto fail;
-
- err = -FDT_ERR_BADOFFSET;
- if (absoffset >= fdt_totalsize(fdt))
- goto fail;
- len = fdt_totalsize(fdt) - absoffset;
-
- if (fdt_magic(fdt) == FDT_MAGIC) {
- if (stroffset < 0)
- goto fail;
- if (fdt_version(fdt) >= 17) {
- if (stroffset >= fdt_size_dt_strings(fdt))
- goto fail;
- if ((fdt_size_dt_strings(fdt) - stroffset) < len)
- len = fdt_size_dt_strings(fdt) - stroffset;
- }
- } else if (fdt_magic(fdt) == FDT_SW_MAGIC) {
- if ((stroffset >= 0)
- || (stroffset < -fdt_size_dt_strings(fdt)))
- goto fail;
- if ((-stroffset) < len)
- len = -stroffset;
- } else {
- err = -FDT_ERR_INTERNAL;
- goto fail;
- }
-
- s = (const char *)fdt + absoffset;
- n = memchr(s, '\0', len);
- if (!n) {
- /* missing terminating NULL */
- err = -FDT_ERR_TRUNCATED;
- goto fail;
- }
-
- if (lenp)
- *lenp = n - s;
- return s;
-
-fail:
- if (lenp)
- *lenp = err;
- return NULL;
-}
-
const char *fdt_string(const void *fdt, int stroffset)
{
- return fdt_get_string(fdt, stroffset, NULL);
+ return (const char *)fdt + fdt_off_dt_strings(fdt) + stroffset;
}
static int fdt_string_eq_(const void *fdt, int stroffset,
const char *s, int len)
{
- int slen;
- const char *p = fdt_get_string(fdt, stroffset, &slen);
+ const char *p = fdt_string(fdt, stroffset);
- return p && (slen == len) && (memcmp(p, s, len) == 0);
+ return (strlen(p) == len) && (memcmp(p, s, len) == 0);
}
uint32_t fdt_get_max_phandle(const void *fdt)
return 0;
}
-static const struct fdt_reserve_entry *fdt_mem_rsv(const void *fdt, int n)
-{
- int offset = n * sizeof(struct fdt_reserve_entry);
- int absoffset = fdt_off_mem_rsvmap(fdt) + offset;
-
- if (absoffset < fdt_off_mem_rsvmap(fdt))
- return NULL;
- if (absoffset > fdt_totalsize(fdt) - sizeof(struct fdt_reserve_entry))
- return NULL;
- return fdt_mem_rsv_(fdt, n);
-}
-
int fdt_get_mem_rsv(const void *fdt, int n, uint64_t *address, uint64_t *size)
{
- const struct fdt_reserve_entry *re;
-
- FDT_RO_PROBE(fdt);
- re = fdt_mem_rsv(fdt, n);
- if (!re)
- return -FDT_ERR_BADOFFSET;
-
- *address = fdt64_ld(&re->address);
- *size = fdt64_ld(&re->size);
+ FDT_CHECK_HEADER(fdt);
+ *address = fdt64_to_cpu(fdt_mem_rsv_(fdt, n)->address);
+ *size = fdt64_to_cpu(fdt_mem_rsv_(fdt, n)->size);
return 0;
}
int fdt_num_mem_rsv(const void *fdt)
{
- int i;
- const struct fdt_reserve_entry *re;
+ int i = 0;
- for (i = 0; (re = fdt_mem_rsv(fdt, i)) != NULL; i++) {
- if (fdt64_ld(&re->size) == 0)
- return i;
- }
- return -FDT_ERR_TRUNCATED;
+ while (fdt64_to_cpu(fdt_mem_rsv_(fdt, i)->size) != 0)
+ i++;
+ return i;
}
static int nextprop_(const void *fdt, int offset)
{
int depth;
- FDT_RO_PROBE(fdt);
+ FDT_CHECK_HEADER(fdt);
for (depth = 0;
(offset >= 0) && (depth >= 0);
const char *p = path;
int offset = 0;
- FDT_RO_PROBE(fdt);
+ FDT_CHECK_HEADER(fdt);
/* see if we have an alias */
if (*path != '/') {
const char *nameptr;
int err;
- if (((err = fdt_ro_probe_(fdt)) != 0)
+ if (((err = fdt_check_header(fdt)) != 0)
|| ((err = fdt_check_node_offset_(fdt, nodeoffset)) < 0))
goto fail;
prop = fdt_offset_ptr_(fdt, offset);
if (lenp)
- *lenp = fdt32_ld(&prop->len);
+ *lenp = fdt32_to_cpu(prop->len);
return prop;
}
offset = -FDT_ERR_INTERNAL;
break;
}
- if (fdt_string_eq_(fdt, fdt32_ld(&prop->nameoff),
+ if (fdt_string_eq_(fdt, fdt32_to_cpu(prop->nameoff),
name, namelen)) {
if (poffset)
*poffset = offset;
/* Handle realignment */
if (fdt_version(fdt) < 0x10 && (poffset + sizeof(*prop)) % 8 &&
- fdt32_ld(&prop->len) >= 8)
+ fdt32_to_cpu(prop->len) >= 8)
return prop->data + 4;
return prop->data;
}
prop = fdt_get_property_by_offset_(fdt, offset, lenp);
if (!prop)
return NULL;
- if (namep) {
- const char *name;
- int namelen;
- name = fdt_get_string(fdt, fdt32_ld(&prop->nameoff),
- &namelen);
- if (!name) {
- if (lenp)
- *lenp = namelen;
- return NULL;
- }
- *namep = name;
- }
+ if (namep)
+ *namep = fdt_string(fdt, fdt32_to_cpu(prop->nameoff));
/* Handle realignment */
if (fdt_version(fdt) < 0x10 && (offset + sizeof(*prop)) % 8 &&
- fdt32_ld(&prop->len) >= 8)
+ fdt32_to_cpu(prop->len) >= 8)
return prop->data + 4;
return prop->data;
}
return 0;
}
- return fdt32_ld(php);
+ return fdt32_to_cpu(*php);
}
const char *fdt_get_alias_namelen(const void *fdt,
int offset, depth, namelen;
const char *name;
- FDT_RO_PROBE(fdt);
+ FDT_CHECK_HEADER(fdt);
if (buflen < 2)
return -FDT_ERR_NOSPACE;
int offset, depth;
int supernodeoffset = -FDT_ERR_INTERNAL;
- FDT_RO_PROBE(fdt);
+ FDT_CHECK_HEADER(fdt);
if (supernodedepth < 0)
return -FDT_ERR_NOTFOUND;
const void *val;
int len;
- FDT_RO_PROBE(fdt);
+ FDT_CHECK_HEADER(fdt);
/* FIXME: The algorithm here is pretty horrible: we scan each
* property of a node in fdt_getprop(), then if that didn't
if ((phandle == 0) || (phandle == -1))
return -FDT_ERR_BADPHANDLE;
- FDT_RO_PROBE(fdt);
+ FDT_CHECK_HEADER(fdt);
/* FIXME: The algorithm here is pretty horrible: we
* potentially scan each property of a node in
{
int offset, err;
- FDT_RO_PROBE(fdt);
+ FDT_CHECK_HEADER(fdt);
/* FIXME: The algorithm here is pretty horrible: we scan each
* property of a node in fdt_node_check_compatible(), then if
return offset; /* error from fdt_next_node() */
}
-
-int fdt_check_full(const void *fdt, size_t bufsize)
-{
- int err;
- int num_memrsv;
- int offset, nextoffset = 0;
- uint32_t tag;
- unsigned depth = 0;
- const void *prop;
- const char *propname;
-
- if (bufsize < FDT_V1_SIZE)
- return -FDT_ERR_TRUNCATED;
- err = fdt_check_header(fdt);
- if (err != 0)
- return err;
- if (bufsize < fdt_totalsize(fdt))
- return -FDT_ERR_TRUNCATED;
-
- num_memrsv = fdt_num_mem_rsv(fdt);
- if (num_memrsv < 0)
- return num_memrsv;
-
- while (1) {
- offset = nextoffset;
- tag = fdt_next_tag(fdt, offset, &nextoffset);
-
- if (nextoffset < 0)
- return nextoffset;
-
- switch (tag) {
- case FDT_NOP:
- break;
-
- case FDT_END:
- if (depth != 0)
- return -FDT_ERR_BADSTRUCTURE;
- return 0;
-
- case FDT_BEGIN_NODE:
- depth++;
- if (depth > INT_MAX)
- return -FDT_ERR_BADSTRUCTURE;
- break;
-
- case FDT_END_NODE:
- if (depth == 0)
- return -FDT_ERR_BADSTRUCTURE;
- depth--;
- break;
-
- case FDT_PROP:
- prop = fdt_getprop_by_offset(fdt, offset, &propname,
- &err);
- if (!prop)
- return err;
- break;
-
- default:
- return -FDT_ERR_INTERNAL;
- }
- }
-}
(fdt_off_dt_strings(fdt) + fdt_size_dt_strings(fdt)));
}
-static int fdt_rw_probe_(void *fdt)
+static int fdt_rw_check_header_(void *fdt)
{
- FDT_RO_PROBE(fdt);
+ FDT_CHECK_HEADER(fdt);
if (fdt_version(fdt) < 17)
return -FDT_ERR_BADVERSION;
return 0;
}
-#define FDT_RW_PROBE(fdt) \
+#define FDT_RW_CHECK_HEADER(fdt) \
{ \
int err_; \
- if ((err_ = fdt_rw_probe_(fdt)) != 0) \
+ if ((err_ = fdt_rw_check_header_(fdt)) != 0) \
return err_; \
}
struct fdt_reserve_entry *re;
int err;
- FDT_RW_PROBE(fdt);
+ FDT_RW_CHECK_HEADER(fdt);
re = fdt_mem_rsv_w_(fdt, fdt_num_mem_rsv(fdt));
err = fdt_splice_mem_rsv_(fdt, re, 0, 1);
{
struct fdt_reserve_entry *re = fdt_mem_rsv_w_(fdt, n);
- FDT_RW_PROBE(fdt);
+ FDT_RW_CHECK_HEADER(fdt);
if (n >= fdt_num_mem_rsv(fdt))
return -FDT_ERR_NOTFOUND;
int oldlen, newlen;
int err;
- FDT_RW_PROBE(fdt);
+ FDT_RW_CHECK_HEADER(fdt);
namep = (char *)(uintptr_t)fdt_get_name(fdt, nodeoffset, &oldlen);
if (!namep)
struct fdt_property *prop;
int err;
- FDT_RW_PROBE(fdt);
+ FDT_RW_CHECK_HEADER(fdt);
err = fdt_resize_property_(fdt, nodeoffset, name, len, &prop);
if (err == -FDT_ERR_NOTFOUND)
struct fdt_property *prop;
int err, oldlen, newlen;
- FDT_RW_PROBE(fdt);
+ FDT_RW_CHECK_HEADER(fdt);
prop = fdt_get_property_w(fdt, nodeoffset, name, &oldlen);
if (prop) {
struct fdt_property *prop;
int len, proplen;
- FDT_RW_PROBE(fdt);
+ FDT_RW_CHECK_HEADER(fdt);
prop = fdt_get_property_w(fdt, nodeoffset, name, &len);
if (!prop)
uint32_t tag;
fdt32_t *endtag;
- FDT_RW_PROBE(fdt);
+ FDT_RW_CHECK_HEADER(fdt);
offset = fdt_subnode_offset_namelen(fdt, parentoffset, name, namelen);
if (offset >= 0)
{
int endoffset;
- FDT_RW_PROBE(fdt);
+ FDT_RW_CHECK_HEADER(fdt);
endoffset = fdt_node_end_offset_(fdt, nodeoffset);
if (endoffset < 0)
const char *fdtend = fdtstart + fdt_totalsize(fdt);
char *tmp;
- FDT_RO_PROBE(fdt);
+ FDT_CHECK_HEADER(fdt);
mem_rsv_size = (fdt_num_mem_rsv(fdt)+1)
* sizeof(struct fdt_reserve_entry);
{
int mem_rsv_size;
- FDT_RW_PROBE(fdt);
+ FDT_RW_CHECK_HEADER(fdt);
mem_rsv_size = (fdt_num_mem_rsv(fdt)+1)
* sizeof(struct fdt_reserve_entry);
#include "libfdt_internal.h"
-static int fdt_sw_probe_(void *fdt)
+static int fdt_sw_check_header_(void *fdt)
{
- if (fdt_magic(fdt) == FDT_MAGIC)
- return -FDT_ERR_BADSTATE;
- else if (fdt_magic(fdt) != FDT_SW_MAGIC)
+ if (fdt_magic(fdt) != FDT_SW_MAGIC)
return -FDT_ERR_BADMAGIC;
+ /* FIXME: should check more details about the header state */
return 0;
}
-#define FDT_SW_PROBE(fdt) \
- { \
- int err; \
- if ((err = fdt_sw_probe_(fdt)) != 0) \
- return err; \
- }
-
-/* 'memrsv' state: Initial state after fdt_create()
- *
- * Allowed functions:
- * fdt_add_reservmap_entry()
- * fdt_finish_reservemap() [moves to 'struct' state]
- */
-static int fdt_sw_probe_memrsv_(void *fdt)
-{
- int err = fdt_sw_probe_(fdt);
- if (err)
- return err;
-
- if (fdt_off_dt_strings(fdt) != 0)
- return -FDT_ERR_BADSTATE;
- return 0;
-}
-
-#define FDT_SW_PROBE_MEMRSV(fdt) \
- { \
- int err; \
- if ((err = fdt_sw_probe_memrsv_(fdt)) != 0) \
- return err; \
- }
-
-/* 'struct' state: Enter this state after fdt_finish_reservemap()
- *
- * Allowed functions:
- * fdt_begin_node()
- * fdt_end_node()
- * fdt_property*()
- * fdt_finish() [moves to 'complete' state]
- */
-static int fdt_sw_probe_struct_(void *fdt)
-{
- int err = fdt_sw_probe_(fdt);
- if (err)
- return err;
-
- if (fdt_off_dt_strings(fdt) != fdt_totalsize(fdt))
- return -FDT_ERR_BADSTATE;
- return 0;
-}
-
-#define FDT_SW_PROBE_STRUCT(fdt) \
+#define FDT_SW_CHECK_HEADER(fdt) \
{ \
int err; \
- if ((err = fdt_sw_probe_struct_(fdt)) != 0) \
+ if ((err = fdt_sw_check_header_(fdt)) != 0) \
return err; \
}
-/* 'complete' state: Enter this state after fdt_finish()
- *
- * Allowed functions: none
- */
-
static void *fdt_grab_space_(void *fdt, size_t len)
{
int offset = fdt_size_dt_struct(fdt);
int fdt_create(void *buf, int bufsize)
{
- const size_t hdrsize = FDT_ALIGN(sizeof(struct fdt_header),
- sizeof(struct fdt_reserve_entry));
void *fdt = buf;
- if (bufsize < hdrsize)
+ if (bufsize < sizeof(struct fdt_header))
return -FDT_ERR_NOSPACE;
memset(buf, 0, bufsize);
fdt_set_last_comp_version(fdt, FDT_FIRST_SUPPORTED_VERSION);
fdt_set_totalsize(fdt, bufsize);
- fdt_set_off_mem_rsvmap(fdt, hdrsize);
+ fdt_set_off_mem_rsvmap(fdt, FDT_ALIGN(sizeof(struct fdt_header),
+ sizeof(struct fdt_reserve_entry)));
fdt_set_off_dt_struct(fdt, fdt_off_mem_rsvmap(fdt));
- fdt_set_off_dt_strings(fdt, 0);
+ fdt_set_off_dt_strings(fdt, bufsize);
return 0;
}
size_t headsize, tailsize;
char *oldtail, *newtail;
- FDT_SW_PROBE(fdt);
+ FDT_SW_CHECK_HEADER(fdt);
- headsize = fdt_off_dt_struct(fdt) + fdt_size_dt_struct(fdt);
+ headsize = fdt_off_dt_struct(fdt);
tailsize = fdt_size_dt_strings(fdt);
- if ((headsize + tailsize) > fdt_totalsize(fdt))
- return -FDT_ERR_INTERNAL;
-
if ((headsize + tailsize) > bufsize)
return -FDT_ERR_NOSPACE;
memmove(buf, fdt, headsize);
}
+ fdt_set_off_dt_strings(buf, bufsize);
fdt_set_totalsize(buf, bufsize);
- if (fdt_off_dt_strings(buf))
- fdt_set_off_dt_strings(buf, bufsize);
return 0;
}
struct fdt_reserve_entry *re;
int offset;
- FDT_SW_PROBE_MEMRSV(fdt);
+ FDT_SW_CHECK_HEADER(fdt);
+
+ if (fdt_size_dt_struct(fdt))
+ return -FDT_ERR_BADSTATE;
offset = fdt_off_dt_struct(fdt);
if ((offset + sizeof(*re)) > fdt_totalsize(fdt))
int fdt_finish_reservemap(void *fdt)
{
- int err = fdt_add_reservemap_entry(fdt, 0, 0);
-
- if (err)
- return err;
-
- fdt_set_off_dt_strings(fdt, fdt_totalsize(fdt));
- return 0;
+ return fdt_add_reservemap_entry(fdt, 0, 0);
}
int fdt_begin_node(void *fdt, const char *name)
{
struct fdt_node_header *nh;
- int namelen;
+ int namelen = strlen(name) + 1;
- FDT_SW_PROBE_STRUCT(fdt);
+ FDT_SW_CHECK_HEADER(fdt);
- namelen = strlen(name) + 1;
nh = fdt_grab_space_(fdt, sizeof(*nh) + FDT_TAGALIGN(namelen));
if (! nh)
return -FDT_ERR_NOSPACE;
{
fdt32_t *en;
- FDT_SW_PROBE_STRUCT(fdt);
+ FDT_SW_CHECK_HEADER(fdt);
en = fdt_grab_space_(fdt, FDT_TAGSIZE);
if (! en)
struct fdt_property *prop;
int nameoff;
- FDT_SW_PROBE_STRUCT(fdt);
+ FDT_SW_CHECK_HEADER(fdt);
nameoff = fdt_find_add_string_(fdt, name);
if (nameoff == 0)
uint32_t tag;
int offset, nextoffset;
- FDT_SW_PROBE_STRUCT(fdt);
+ FDT_SW_CHECK_HEADER(fdt);
/* Add terminator */
end = fdt_grab_space_(fdt, sizeof(*end));
#define FDT_ALIGN(x, a) (((x) + (a) - 1) & ~((a) - 1))
#define FDT_TAGALIGN(x) (FDT_ALIGN((x), FDT_TAGSIZE))
-int fdt_ro_probe_(const void *fdt);
-#define FDT_RO_PROBE(fdt) \
+#define FDT_CHECK_HEADER(fdt) \
{ \
int err_; \
- if ((err_ = fdt_ro_probe_(fdt)) != 0) \
+ if ((err_ = fdt_check_header(fdt)) != 0) \
return err_; \
}
projects / project / bcm63xx / atf.git / commitdiff